home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / listings / v_12_09 / single2 / maintest.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-07  |  4.4 KB  |  162 lines
  1. //  Listing 9
  2. //  maintest.cpp
  3. //  contains the code for the main test routines 
  4. //  for access to the global heap
  5. //
  6. //  Copyright Singleton Systems Ltd 1994
  7.  
  8. #include    "stdafx.h" 
  9. #include    "newtest.h" 
  10. #include    "mobject.h"
  11. #include    "farheapb.h"
  12. #include    <iostream.h> 
  13. #include    <fstream.h>
  14. #include    <iomanip.h>
  15. #include    "cmostr.h"
  16.  
  17. class FAR sort_node : public MemoryObject
  18. { 
  19. private:
  20. int value,              //  The number to sort on
  21.     original_order;     //  The order prior to sorting
  22. sort_node * less_equal, //  Pointer to sort_node tree
  23.                         //  holding sort-nodes with
  24.           * greater;    //  Pointer to sort_node tree
  25.                         //  holding sort-nodes with 
  26.                         //  value > this->value
  27. char filler [1000];     //  To make a sort_node bigger
  28.                         //  for test purposes
  29. public:  
  30. sort_node ();
  31. void read_node (ifstream &in);
  32.                         //  Reads a sort_node from <in>
  33. void enter_item (sort_node * item);
  34.                         //  Traverses a sort_node tree
  35.                         //  to insert item at the right
  36.                         //  point.
  37. void write_node (ofstream &out);  
  38.                         //  Writes the contents of a
  39.                         //  sort_node to <out>
  40. static sort_node * unlink_least_item 
  41.         (sort_node FAR * FAR * pp_branch);
  42.                         //  Traverses a sort_node
  43.                         //  branch, looking for the
  44.                         //  least item.  When the 
  45.                         //  least item is found, it is
  46.                         //  unlinked from the branch.
  47.                         //  Returns a pointer to the
  48.                         //  least item.
  49. };
  50.  
  51. sort_node::sort_node ()
  52.     {less_equal = greater = NULL;}
  53.  
  54. void sort_node::read_node (ifstream &file_in)
  55. {
  56. ASSERT (this != NULL);
  57. int item1, item2;
  58. file_in >> item1 >> item2; 
  59. value = item1; original_order = item2;
  60. }
  61.  
  62. void sort_node::write_node (ofstream &out)
  63. {
  64. #pragma warning (disable: 4270)
  65. //  stop unwanted warnings from iomanip.h
  66. ASSERT (this != NULL);
  67. out << dec << setw (10) << value << setw (10) 
  68.     << original_order << endl;
  69. #pragma warning (default: 4270)
  70. }
  71.  
  72. void sort_node::enter_item (sort_node * item)
  73. {
  74. if (item->value <= value)
  75.     {
  76.     if (less_equal == NULL)
  77.         less_equal = item;
  78.     else less_equal->enter_item (item);
  79.     }
  80. else
  81.     {
  82.     if (greater == NULL)
  83.         greater = item;
  84.     else greater->enter_item (item);
  85.     }   
  86. }
  87.  
  88. sort_node * sort_node::unlink_least_item 
  89.         (sort_node FAR * FAR * pp_branch)
  90. {
  91. if ((*pp_branch)->less_equal != NULL)
  92.     //  Search down the less_equal branch 
  93.     return unlink_least_item 
  94.                         (&((*pp_branch)->less_equal));
  95. else
  96.     {   //  This node is the least item, so unlink it
  97.     sort_node * current = * pp_branch;
  98.     * pp_branch = current->greater;
  99.     current->less_equal = current->greater = NULL;
  100.     return current;
  101.     }
  102. }
  103.  
  104. sort_node * tree = NULL; 
  105.  
  106. #define new MO_DEBUG_NEW
  107.  
  108. void CComdtestApp::DoTest ()
  109. {
  110. cout << "CComdtestApp::OnFileOpen () called" << endl;
  111.  
  112. CMOString * tmp_str = new CMOString ("some test text");
  113.     {
  114.     CMOString test = "abc";
  115.     test = test + "def"; 
  116.     cout << "test = " << test << endl;
  117.     }
  118.  
  119. void FAR * p_tmp = MemoryObject::AllocateBlock (21);
  120. MemoryObject::ReturnBlock (p_tmp); 
  121.  
  122. ifstream fin ("newtest.txt", ios::in | ios::nocreate);
  123. ASSERT (fin.is_open());
  124. int no_of_entries;
  125. fin >> no_of_entries; 
  126. ASSERT (no_of_entries >=1);
  127. tree = new sort_node;
  128. tree->read_node (fin);
  129. for (int i = 2; i <= no_of_entries; i++)
  130.     {
  131.     sort_node * item = new sort_node;
  132.     item->read_node (fin);
  133.     tree->enter_item (item);
  134.     }
  135.  
  136. CMOString * tmp_str2 = 
  137.                 new CMOString ("some more test text");
  138.  
  139. fin.close ();   
  140. }
  141.  
  142. void CComdtestApp::OnFileClose ()
  143. {
  144. //  We misuse the OnFileClose function to delete the 
  145. //  sort tree and to generate a heap report.  We do
  146. //  not really close anything.
  147. cout << "CComdtestApp::OnFileClose () called" << endl;
  148. if (tree != NULL)
  149.     {
  150.     ofstream fout ("newrpt.txt");           
  151.     while (tree != NULL)
  152.         {
  153.         sort_node * least_item = 
  154.                 sort_node::unlink_least_item (&tree);
  155.         least_item->write_node (fout);
  156.         delete least_item;
  157.         }
  158.     CComdtestApp::OnFilePrintHeapReport();    
  159.     fout.close();
  160.     }
  161. }
  162.